SherbyNet - /page/wikibook/entry.mu

<!DOCTYPE html>

<title>First-class function</title>

</head>

First-class function

</h1>

</header>

In <a href="Computer_science" title="Computer science">computer science</a>, a <a href="Programming_language" title="Programming language">programming language</a> is said to have first-class functions if it treats <a href="Function_(programming)" class="mw-redirect" title="Function (programming)">functions</a> as <a href="First-class_citizen" title="First-class citizen">first-class citizens</a>. This means the language supports passing functions as arguments to other functions, returning them as the values from other functions, and assigning them to variables or storing them in data structures.<a href="#cite_note-1">[1]</a> Some programming language theorists require support for <a href="Anonymous_function" title="Anonymous function">anonymous functions</a> (function literals) as well.<a href="#cite_note-test-2">[2]</a> In languages with first-class functions, the <a href="Name_(computer_science)" class="mw-redirect" title="Name (computer science)">names</a> of functions do not have any special status; they are treated like ordinary <a href="Variable_(computer_science)" title="Variable (computer science)">variables</a> with a <a href="Function_type" title="Function type">function type</a>.<a href="#cite_note-3">[3]</a> The term was coined by <a href="Christopher_Strachey" title="Christopher Strachey">Christopher Strachey</a> in the context of "functions as first-class citizens" in the mid-1960s.<a href="#cite_note-strachey-4">[4]</a>

First-class functions are a necessity for the <a href="Functional_programming" title="Functional programming">functional programming</a> style, in which the use of <a href="Higher-order_function" title="Higher-order function">higher-order functions</a> is a standard practice. A simple example of a higher-ordered function is the <a href="Map_(higher-order_function)" title="Map (higher-order function)">map</a> function, which takes, as its arguments, a function and a list, and returns the list formed by applying the function to each member of the list. For a language to support map, it must support passing a function as an argument.

There are certain implementation difficulties in passing functions as arguments or returning them as results, especially in the presence of <a href="Non-local_variable" title="Non-local variable">non-local variables</a> introduced in <a href="Nested_function" title="Nested function">nested</a> and <a href="Anonymous_function" title="Anonymous function">anonymous functions</a>. Historically, these were termed the <a href="Funarg_problem" title="Funarg problem">funarg problems</a>, the name coming from function argument.<a href="#cite_note-5">[5]</a> In early imperative languages these problems were avoided by either not supporting functions as result types (e.g. <a href="ALGOL_60" title="ALGOL 60">ALGOL 60</a>, <a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a>) or omitting nested functions and thus non-local variables (e.g. <a href="C_(programming_language)" title="C (programming language)">C</a>). The early functional language <a href="Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a> took the approach of <a href="Dynamic_scoping" class="mw-redirect" title="Dynamic scoping">dynamic scoping</a>, where non-local variables refer to the closest definition of that variable at the point where the function is executed, instead of where it was defined. Proper support for <a href="Lexically_scoped" class="mw-redirect" title="Lexically scoped">lexically scoped</a> first-class functions was introduced in <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a> and requires handling references to functions as <a href="Closure_(computer_science)" class="mw-redirect" title="Closure (computer science)">closures</a> instead of bare <a href="Function_pointer" title="Function pointer">function pointers</a>,<a href="#cite_note-strachey-4">[4]</a> which in turn makes <a href="Garbage_collection_(computer_science)" title="Garbage collection (computer science)">garbage collection</a> a necessity.

<div class="mw-heading mw-heading2"><h2 id="Concepts">Concepts</h2></div>

In this section, we compare how particular programming idioms are handled in a functional language with first-class functions (<a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a>) compared to an imperative language where functions are second-class citizens (<a href="C_(programming_language)" title="C (programming language)">C</a>).

<div class="mw-heading mw-heading3"><h3 id="Higher-order_functions:_passing_functions_as_arguments">Higher-order functions: passing functions as arguments</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Higher-order_function" title="Higher-order function">Higher-order function</a></div>

In languages where functions are first-class citizens, functions can be passed as arguments to other functions in the same way as other values (a function taking another function as argument is called a higher-order function). In the language <a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a>:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>map :: (a -> b) -> [a] -> [b]

map f [] = []

map f (x:xs) = f x : map f xs

</pre></div>

Languages where functions are not first-class often still allow one to write higher-order functions through the use of features such as <a href="Function_pointer" title="Function pointer">function pointers</a> or <a href="Delegate_(CLI)" title="Delegate (CLI)">delegates</a>. In the language <a href="C_(programming_language)" title="C (programming language)">C</a>:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>void map(int (*f)(int), int x[], size_t n) {

for (int i = 0; i < n; i++)

x[i] = f(x[i]);

}

</pre></div>

There are a number of differences between the two approaches that are not directly related to the support of first-class functions. The Haskell sample operates on <a href="List_(computing)" class="mw-redirect" title="List (computing)">lists</a>, while the C sample operates on <a href="Array_data_structure" class="mw-redirect" title="Array data structure">arrays</a>. Both are the most natural compound data structures in the respective languages and making the C sample operate on linked lists would have made it unnecessarily complex. This also accounts for the fact that the C function needs an additional parameter (giving the size of the array.) The C function updates the array <a href="In-place" class="mw-redirect" title="In-place">in-place</a>, returning no value, whereas in Haskell data structures are <a href="Persistent_data_structure" title="Persistent data structure">persistent</a> (a new list is returned while the old is left intact.) The Haskell sample uses <a href="Recursion" title="Recursion">recursion</a> to traverse the list, while the C sample uses <a href="Iteration" title="Iteration">iteration</a>. Again, this is the most natural way to express this function in both languages, but the Haskell sample could easily have been expressed in terms of a <a href="Fold_(higher-order_function)" title="Fold (higher-order function)">fold</a> and the C sample in terms of recursion. Finally, the Haskell function has a <a href="Polymorphism_(computer_science)" title="Polymorphism (computer science)">polymorphic</a> type, as this is not supported by C we have fixed all type variables to the type constant <code>int</code>.

<div class="mw-heading mw-heading3"><h3 id="Anonymous_and_nested_functions">Anonymous and nested functions</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Anonymous_function" title="Anonymous function">Anonymous function</a> and <a href="Nested_function" title="Nested function">Nested function</a></div>

In languages supporting anonymous functions, we can pass such a function as an argument to a higher-order function:

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>main = map (\x -> 3 * x + 1) [1, 2, 3, 4, 5]

</pre></div>

In a language which does not support anonymous functions, we have to bind it to a name instead:

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>int f(int x) {

return 3 * x + 1;

}

int main() {

int list[] = {1, 2, 3, 4, 5};

map(f, list, 5);

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Non-local_variables_and_closures">Non-local variables and closures</h3></div>

<div role="note" class="hatnote navigation-not-searchable">Further information: <a href="Non-local_variable" title="Non-local variable">Non-local variable</a> and <a href="Closure_(computer_science)" class="mw-redirect" title="Closure (computer science)">Closure (computer science)</a></div>

Once we have anonymous or nested functions, it becomes natural for them to refer to variables outside of their body (called non-local variables):

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>main = let a = 3

b = 1

in map (\x -> a * x + b) [1, 2, 3, 4, 5]

</pre></div>

If functions are represented with bare function pointers, we can not know anymore how the value that is outside of the function's body should be passed to it, and because of that a closure needs to be built manually. Therefore we can not speak of "first-class" functions here.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>typedef struct {

int (*f)(int, int, int);

int a;

int b;

} closure_t;

void map(closure_t *closure, int x[], size_t n) {

for (int i = 0; i < n; ++i)

x[i] = (closure->f)(closure->a, closure->b, x[i]);

}

int f(int a, int b, int x) {

return a * x + b;

}

void main() {

int l[] = {1, 2, 3, 4, 5};

int a = 3;

int b = 1;

closure_t closure = {f, a, b};

map(&closure, l, 5);

}

</pre></div>

Also note that the <code>map</code> is now specialized to functions referring to two <code>int</code>s outside of their environment. This can be set up more generally, but requires more <a href="Boilerplate_code" title="Boilerplate code">boilerplate code</a>. If <code>f</code> would have been a <a href="Nested_function" title="Nested function">nested function</a> we would still have run into the same problem and this is the reason they are not supported in C.<a href="#cite_note-6">[6]</a>

<div class="mw-heading mw-heading3"><h3 id="Higher-order_functions:_returning_functions_as_results">Higher-order functions: returning functions as results</h3></div>

When returning a function, we are in fact returning its closure. In the C example any local variables captured by the closure will go out of scope once we return from the function that builds the closure. Forcing the closure at a later point will result in undefined behaviour, possibly corrupting the stack. This is known as the <a href="Upwards_funarg_problem" class="mw-redirect" title="Upwards funarg problem">upwards funarg problem</a>.

<div class="mw-heading mw-heading3"><h3 id="Assigning_functions_to_variables">Assigning functions to variables</h3></div>

<a href="Assignment_(computer_science)" title="Assignment (computer science)">Assigning</a> functions to <a href="Variable_(computer_science)" title="Variable (computer science)">variables</a> and storing them inside (global) data structures potentially suffers from the same difficulties as returning functions.

<div class="mw-highlight mw-highlight-lang-haskell mw-content-ltr" dir="ltr"><pre>f :: [[Integer] -> [Integer]]

f = let a = 3

b = 1

in [map (\x -> a * x + b), map (\x -> b * x + a)]

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Equality_of_functions">Equality of functions</h3></div>

As one can test most literals and values for equality, it is natural to ask whether a programming language can support testing functions for equality. On further inspection, this question appears more difficult and one has to distinguish between several types of function equality:<a href="#cite_note-7">[7]</a>

<dl><dt><a href="Extensional_equality" class="mw-redirect" title="Extensional equality">Extensional equality</a></dt>

<dd>Two functions f and g are considered extensionally equal if they agree on their outputs for all inputs (∀x. f(x) = g(x)). Under this definition of equality, for example, any two implementations of a <a href="Stable_sorting_algorithm" class="mw-redirect" title="Stable sorting algorithm">stable sorting algorithm</a>, such as <a href="Insertion_sort" title="Insertion sort">insertion sort</a> and <a href="Merge_sort" title="Merge sort">merge sort</a>, would be considered equal. Deciding on extensional equality is <a href="Undecidable_problem" title="Undecidable problem">undecidable</a> in general and even for functions with finite domains often intractable. For this reason no programming language implements function equality as extensional equality.</dd></dl>

<dl><dt><a href="Intensional_equality" class="mw-redirect" title="Intensional equality">Intensional equality</a></dt>

<dd>Under intensional equality, two functions f and g are considered equal if they have the same "internal structure". This kind of equality could be implemented in <a href="Interpreted_language" class="mw-redirect" title="Interpreted language">interpreted languages</a> by comparing the <a href="Source_code" title="Source code">source code</a> of the function bodies (such as in Interpreted Lisp 1.5) or the <a href="Object_code" title="Object code">object code</a> in <a href="Compiled_language" title="Compiled language">compiled languages</a>. Intensional equality implies extensional equality (assuming the functions are deterministic and have no hidden inputs, such as the <a href="Program_counter" title="Program counter">program counter</a> or a mutable <a href="Global_variable" title="Global variable">global variable</a>.)</dd></dl>

<dl><dt>Reference equality</dt>

<dd>Given the impracticality of implementing extensional and intensional equality, most languages supporting testing functions for equality use reference equality. All functions or closures are assigned a unique identifier (usually the address of the function body or the closure) and equality is decided based on equality of the identifier. Two separately defined, but otherwise identical function definitions will be considered unequal. Referential equality implies intensional and extensional equality. Referential equality breaks <a href="Referential_transparency" title="Referential transparency">referential transparency</a> and is therefore not supported in <a href="Pure_function" title="Pure function">pure</a> languages, such as Haskell.</dd></dl>

<div class="mw-heading mw-heading2"><h2 id="Type_theory">Type theory</h2></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Function_type" title="Function type">Function type</a></div>

In <a href="Type_theory" title="Type theory">type theory</a>, the type of functions accepting values of type A and returning values of type B may be written as A → B or BA. In the <a href="Curry%E2%80%93Howard_correspondence" title="Curry–Howard correspondence">Curry–Howard correspondence</a>, <a href="Function_type" title="Function type">function types</a> are related to <a href="Logical_implication" class="mw-redirect" title="Logical implication">logical implication</a>; lambda abstraction corresponds to discharging hypothetical assumptions and function application corresponds to the <a href="Modus_ponens" title="Modus ponens">modus ponens</a> inference rule. Besides the usual case of programming functions, type theory also uses first-class functions to model <a href="Associative_array" title="Associative array">associative arrays</a> and similar <a href="Data_structure" title="Data structure">data structures</a>.

In <a href="Category_theory" title="Category theory">category-theoretical</a> accounts of programming, the availability of first-class functions corresponds to the <a href="Closed_category" title="Closed category">closed category</a> assumption. For instance, the <a href="Simply_typed_lambda_calculus" title="Simply typed lambda calculus">simply typed lambda calculus</a> corresponds to the internal language of <a href="Cartesian_closed_category" title="Cartesian closed category">Cartesian closed categories</a>.

<div class="mw-heading mw-heading2"><h2 id="Language_support">Language support</h2></div>

Functional programming languages, such as <a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a>, <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a>, <a href="ML_(programming_language)" title="ML (programming language)">ML</a>, <a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a>, <a href="F_Sharp_(programming_language)" title="F Sharp (programming language)">F#</a>, and <a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a>, all have first-class functions. When <a href="Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a>, one of the earliest functional languages, was designed, not all aspects of first-class functions were then properly understood, resulting in functions being dynamically scoped. The later <a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a> and <a href="Common_Lisp" title="Common Lisp">Common Lisp</a> dialects do have lexically scoped first-class functions.

Many scripting languages, including <a href="Perl" title="Perl">Perl</a>, <a href="Python_(programming_language)" title="Python (programming language)">Python</a>, <a href="PHP" title="PHP">PHP</a>, <a href="Lua_(programming_language)" class="mw-redirect" title="Lua (programming language)">Lua</a>, <a href="Tcl" title="Tcl">Tcl</a>/Tk, <a href="JavaScript" title="JavaScript">JavaScript</a> and <a href="Io_(programming_language)" title="Io (programming language)">Io</a>, have first-class functions.

For imperative languages, a distinction has to be made between Algol and its descendants such as Pascal, the traditional C family, and the modern garbage-collected variants. The Algol family has allowed nested functions and higher-order taking function as arguments, but not higher-order functions that return functions as results (except Algol 68, which allows this). The reason for this was that it was not known how to deal with non-local variables if a nested-function was returned as a result (and Algol 68 produces runtime errors in such cases).

The C family allowed both passing functions as arguments and returning them as results, but avoided any problems by not supporting nested functions. (The gcc compiler allows them as an extension.) As the usefulness of returning functions primarily lies in the ability to return nested functions that have captured non-local variables, instead of top-level functions, these languages are generally not considered to have first-class functions.

Modern imperative languages often support garbage-collection making the implementation of first-class functions feasible. First-class functions have often only been supported in later revisions of the language, including C# 2.0 and Apple's Blocks extension to C, C++, and Objective-C. C++11 has added support for anonymous functions and closures to the language, but because of the non-garbage collected nature of the language, special care has to be taken for non-local variables in functions to be returned as results (see below).

<th colspan="2" rowspan="2">Language</th>

<th colspan="2"><a href="Higher-order_function" title="Higher-order function">Higher-order functions</a></th>

<th colspan="2"><a href="Nested_function" title="Nested function">Nested functions</a></th>

<th colspan="2"><a href="Non-local_variable" title="Non-local variable">Non-local variables</a></th>

<th rowspan="2" width="25%">Notes

</th></tr>

<tr>

<th>Arguments</th>

<th>Results</th>

<th>Named</th>

<th><a href="Anonymous_function" title="Anonymous function">Anonymous</a></th>

<th><a href="Closure_(computer_programming)" title="Closure (computer programming)">Closures</a></th>

<th><a href="Partial_application" title="Partial application">Partial application</a>

</th></tr>

<tr>

<td rowspan="6">Algol family

</td>

<td><a href="ALGOL_60" title="ALGOL 60">ALGOL 60</a></td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Downwards</td>

<td rowspan="6">Have <a href="Function_type" title="Function type">function types</a>.

</td></tr>

<tr>

<td><a href="ALGOL_68" title="ALGOL 68">ALGOL 68</a></td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Downwards<a href="#cite_note-9">[9]</a></td>

<td style="background:#FFC7C7;color:black;vertical-align:middle;text-align:center;" class="table-no">No

</td></tr>

<tr>

<td><a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a></td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Downwards</td>

<td style="background:#FFC7C7;color:black;vertical-align:middle;text-align:center;" class="table-no">No

</td></tr>

<tr>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Downwards</td>

<td style="background:#FFC7C7;color:black;vertical-align:middle;text-align:center;" class="table-no">No

</td></tr>

<tr>

<td><a href="Oberon_(programming_language)" title="Oberon (programming language)">Oberon</a></td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Non-nested only</td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Downwards</td>

<td style="background:#FFC7C7;color:black;vertical-align:middle;text-align:center;" class="table-no">No

</td></tr>

<tr>

<td><a href="Delphi_(programming_language)" class="mw-redirect" title="Delphi (programming language)">Delphi</a></td>

<td style="background:#FFC7C7;color:black;vertical-align:middle;text-align:center;" class="table-no">No

</td></tr>

<tr>

<td rowspan="9">C family

</td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Yes in Clang(<a href="Blocks_(C_language_extension)" title="Blocks (C language extension)">Blocks</a>)</td>

<td>Has <a href="Function_pointer" title="Function pointer">function pointers</a>.

</td></tr>

<tr>

<td>Has function pointers, <a href="Function_object" title="Function object">function objects</a>. (Also, see below.)

Explicit partial application possible with <code>std::bind</code>.

</td></tr>

<tr>

<td>Has <a href="Delegate_(CLI)" title="Delegate (CLI)">delegates</a> (2.0) and lambda expressions (3.0).

</td></tr>

<tr>

<td><a href="Objective-C" title="Objective-C">Objective-C</a></td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Using anonymous</td>

<td style="background:#9EFF9E;color:black;vertical-align:middle;text-align:center;" class="table-yes">2.0 + Blocks<a href="#cite_note-12">[12]</a></td>

<td style="background:#9EFF9E;color:black;vertical-align:middle;text-align:center;" class="table-yes">2.0 + Blocks</td>

<td>Has function pointers.

</td></tr>

<tr>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Using anonymous</td>

<td>Has <a href="Anonymous_inner_class" class="mw-redirect" title="Anonymous inner class">anonymous inner classes</a>.

</td></tr>

<tr>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Using anonymous</td>

<td>

</td></tr>

<tr>

<td><a href="Limbo_(programming_language)" title="Limbo (programming language)">Limbo</a></td>

<td>

</td></tr>

<tr>

<td><a href="Newsqueak" title="Newsqueak">Newsqueak</a></td>

<td>

</td></tr>

<tr>

<td>

</td></tr>

<tr>

<td rowspan="12">Functional languages</td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Syntax</td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Common Lisp</td>

<td>(see below)

</td></tr>

<tr>

<td><a href="Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a></td>

<td>

</td></tr>

<tr>

<td><a href="Julia_(programming_language)" title="Julia (programming language)">Julia</a></td>

<td>

</td></tr>

<tr>

<td><a href="Clojure" title="Clojure">Clojure</a></td>

<td>

</td></tr>

<tr>

<td>

</td></tr>

<tr>

<td><a href="Haskell_(programming_language)" class="mw-redirect" title="Haskell (programming language)">Haskell</a></td>

<td>

</td></tr>

<tr>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Expressions only</td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Downwards</td>

<td style="background:#FFC7C7;color:black;vertical-align:middle;text-align:center;" class="table-no">No

</td></tr>

<tr>

<td><a href="Scala_(programming_language)" title="Scala (programming language)">Scala</a></td>

<td>

</td></tr>

<tr>

<td><a href="Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a></td>

<td>

</td></tr>

<tr>

<td><a href="Elixir_(programming_language)" title="Elixir (programming language)">Elixir</a></td>

<td>

</td></tr>

<tr>

<td>

</td></tr>

<tr>

<td><a href="OCaml" title="OCaml">OCaml</a></td>

<td>

</td></tr>

<tr>

<td rowspan="7">Scripting languages

</td>

<td>

</td></tr>

<tr>

<td><a href="JavaScript" title="JavaScript">JavaScript</a></td>

<td style="background:#9EFF9E;color:black;vertical-align:middle;text-align:center;" class="table-yes">ECMAScript 5</td>

<td>Partial application possible with user-land code on ES3 <a href="#cite_note-16">[16]</a>

</td></tr>

<tr>

<td>

</td></tr>

<tr>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Using anonymous</td>

<td>Partial application possible with user-land code.

</td></tr>

<tr>

<td>

</td></tr>

<tr>

<td><a href="Python_(programming_language)" title="Python (programming language)">Python</a></td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Expressions only</td>

<td>(see below)

</td></tr>

<tr>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Syntax</td>

<td style="background:#FFC7C7;color:black;vertical-align:middle;text-align:center;" class="table-no">Unscoped</td>

<td>(see below)

</td></tr>

<tr>

<td rowspan="6">Other languages

</td>

<td><a href="Fortran" title="Fortran">Fortran</a></td>

<td>

</td></tr>

<tr>

<td><a href="Maple_(software)" title="Maple (software)">Maple</a></td>

<td>

</td></tr>

<tr>

<td><a href="Mathematica" class="mw-redirect" title="Mathematica">Mathematica</a></td>

<td>

</td></tr>

<tr>

<td><a href="MATLAB" title="MATLAB">MATLAB</a></td>

<td>Partial application possible by automatic generation of new functions.<a href="#cite_note-21">[21]</a>

</td></tr>

<tr>

<td><a href="Smalltalk" title="Smalltalk">Smalltalk</a></td>

<td style="background:#FFB; color:black;vertical-align:middle;text-align:center;" class="table-partial">Partial</td>

<td>Partial application possible through library.

</td></tr>

<tr>

<td><a href="Swift_(programming_language)" title="Swift (programming language)">Swift</a></td>

<td>

</td></tr></tbody></table>

<dd><a href="C%2B%2B11" title="C++11">C++11</a> closures can capture non-local variables by copy construction, by reference (without extending their lifetime), or by <a href="C%2B%2B11#Rvalue_references_and_move_constructors" title="C++11">move construction</a> (the variable lives as long as the closure does). The first option is safe if the closure is returned but requires a copy and cannot be used to modify the original variable (which might not exist any more at the time the closure is called). The second option potentially avoids an expensive copy and allows to modify the original variable but is unsafe in case the closure is returned (see <a href="Dangling_reference" class="mw-redirect" title="Dangling reference">dangling references</a>). The third option is safe if the closure is returned and does not require a copy but cannot be used to modify the original variable either.</dd>

<dd><a href="Java_8" class="mw-redirect" title="Java 8">Java 8</a> closures can only capture final or "effectively final" non-local variables. Java's <a href="Function_type" title="Function type">function types</a> are represented as Classes. Anonymous functions take the type inferred from the context. Method references are limited. For more details, see <a href="Anonymous_function#Java_limitations" title="Anonymous function">Anonymous function § Java limitations</a>.</dd>

<dd><a href="Lexically_scoped" class="mw-redirect" title="Lexically scoped">Lexically scoped</a> Lisp variants support closures. <a href="Dynamically_scoped" class="mw-redirect" title="Dynamically scoped">Dynamically scoped</a> variants do not support closures or need a special construct to create closures.<a href="#cite_note-22">[22]</a></dd>

<dd>In <a href="Common_Lisp" title="Common Lisp">Common Lisp</a>, the identifier of a function in the function namespace cannot be used as a reference to a first-class value. The special operator <code>function</code> must be used to retrieve the function as a value: <code>(function foo)</code> evaluates to a function object. <code>#'foo</code> exists as a shorthand notation. To apply such a function object, one must use the <code>funcall</code> function: <code>(funcall #'foo bar baz)</code>.</dd>

<dt>Python</dt>

<dd>Explicit partial application with <code><a rel="nofollow" class="external text" href="https://docs.python.org/library/functools.html#functools.partial">functools.partial</a></code> since version 2.5, and <code><a rel="nofollow" class="external text" href="https://docs.python.org/library/operator.html#operator.methodcaller">operator.methodcaller</a></code> since version 2.6.</dd>

<dd>The identifier of a regular "function" in Ruby (which is really a method) cannot be used as a value or passed. It must first be retrieved into a <code>Method</code> or <code>Proc</code> object to be used as first-class data. The syntax for calling such a function object differs from calling regular methods.</dd>

<dd>Nested method definitions do not actually nest the scope.</dd>

<dd>Explicit currying with <code><a rel="nofollow" class="external autonumber" href="https://docs.ruby-lang.org/en/master/Proc.html#method-i-curry">[1]</a></code>.</dd></dl>

<ul><li><a href="Defunctionalization" title="Defunctionalization">Defunctionalization</a></li>

<li><a href="First-class_message" title="First-class message">First-class message</a></li>

<li><a href="Kappa_calculus" title="Kappa calculus">Kappa calculus</a> – a formalism which excludes first-class functions</li>

<li><a href="Partial_application" title="Partial application">Partial application</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="Notes">Notes</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist reflist-columns references-column-width reflist-columns-2">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFAbelsonSussman1984" class="citation book cs1"><a href="Harold_Abelson" class="mw-redirect" title="Harold Abelson">Abelson, Harold</a>; <a href="Gerald_Jay_Sussman" title="Gerald Jay Sussman">Sussman, Gerald Jay</a> (1984). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20210921155625/https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-12.html#%_sec_1.3">Structure and Interpretation of Computer Programs</a>. MIT Press. <a rel="nofollow" class="external text" href="https://archive.org/details/structureinterpr00abel/page/">Formulating Abstractions with Higher-Order Procedures</a>. <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-262-01077-1</bdi>. Archived from <a rel="nofollow" class="external text" href="https://mitpress.mit.edu/sites/default/files/sicp/full-text/book/book-Z-H-12.html#%_sec_1.3">the original</a> on 2021-09-21. Retrieved 2021-09-27.</cite>

</li>

<li id="cite_note-test-2"><a href="#cite_ref-test_2-0">^</a> <a rel="nofollow" class="external text" href="http://www.worldcat.org/oclc/222529448">Programming language pragmatics</a>, by Michael Lee Scott, section 11.2 "Functional Programming".

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite id="CITEREFRoberto_IerusalimschyLuiz_Henrique_de_FigueiredoWaldemar_Celes2005" class="citation journal cs1"><a href="Roberto_Ierusalimschy" title="Roberto Ierusalimschy">Roberto Ierusalimschy</a>; Luiz Henrique de Figueiredo; Waldemar Celes (2005). <a rel="nofollow" class="external text" href="https://doi.org/10.3217%2Fjucs-011-07-1159">"The Implementation of Lua 5.0"</a>. Journal of Universal Computer Science. 11 (7): 1159–1176. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.3217%2Fjucs-011-07-1159">10.3217/jucs-011-07-1159</a>.</cite>

</li>

<li id="cite_note-strachey-4">^ <a href="#cite_ref-strachey_4-0">a</a> <a href="#cite_ref-strachey_4-1">b</a> <cite id="CITEREFBurstallStrachey2000" class="citation journal cs1">Burstall, Rod; Strachey, Christopher (2000). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20100216060948/http://www.cs.cmu.edu/~crary/819-f09/Strachey67.pdf">"Understanding Programming Languages"</a> (PDF). <a href="Higher-Order_and_Symbolic_Computation" title="Higher-Order and Symbolic Computation">Higher-Order and Symbolic Computation</a>. 13 (52): 11–49. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1023%2FA%3A1010052305354">10.1023/A:1010052305354</a>. <a href="S2CID_(identifier)" class="mw-redirect" title="S2CID (identifier)">S2CID</a> <a rel="nofollow" class="external text" href="https://api.semanticscholar.org/CorpusID:1989590">1989590</a>. Archived from the original on February 16, 2010.</cite><code class="cs1-code">{{cite journal}}</code>: CS1 maint: bot: original URL status unknown (link) (also on 2010-02-16

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <a href="Joel_Moses" title="Joel Moses">Joel Moses</a>. <a rel="nofollow" class="external text" href="https://dspace.mit.edu/handle/1721.1/5854">"The Function of FUNCTION in LISP, or Why the FUNARG Problem Should be Called the Environment Problem"</a>. MIT AI Memo 199, 1970.

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> "If you try to call the nested function through its address after the containing function has exited, all hell will break loose." (<a rel="nofollow" class="external text" href="https://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Nested-Functions.html#Nested-Functions">GNU Compiler Collection: Nested Functions</a>)

</li>

<li id="cite_note-7"><a href="#cite_ref-7">^</a> <a href="Andrew_W._Appel" class="mw-redirect" title="Andrew W. Appel">Andrew W. Appel</a> (1995). <a rel="nofollow" class="external text" href="http://www.cs.princeton.edu/~appel/papers/conteq.pdf">"Intensional Equality ;=) for Continuations"</a>.

</li>

<li id="cite_note-compa68pascal-8"><a href="#cite_ref-compa68pascal_8-0">^</a> <cite id="CITEREFTanenbaum1977" class="citation journal cs1">Tanenbaum, A.S. (1977). <a rel="nofollow" class="external text" href="https://research.vu.nl/files/110789276/11054">"A comparison of PASCAL and Algol 68"</a>. The Computer Journal. 21 (4): 319. <a href="Doi_(identifier)" class="mw-redirect" title="Doi (identifier)">doi</a>:<a rel="nofollow" class="external text" href="https://doi.org/10.1093%2Fcomjnl%2F21.4.316">10.1093/comjnl/21.4.316</a>.</cite>

</li>

<li id="cite_note-9"><a href="#cite_ref-9">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://python-history.blogspot.nl/2009/04/origins-of-pythons-functional-features.html?showComment=1243166621952#c702829329923892023">"The History of Python: Origins of Python's "Functional" Features"</a>. 21 April 2009.</cite>

</li>

<li id="cite_note-10"><a href="#cite_ref-10">^</a> <a rel="nofollow" class="external text" href="https://stackoverflow.com/a/4324829">Nested functions using lambdas/closures</a>

</li>

<li id="cite_note-doc1968-11">^ <a href="#cite_ref-doc1968_11-0">a</a> <a href="#cite_ref-doc1968_11-1">b</a> Doc No. <a rel="nofollow" class="external text" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n1968.pdf">1968</a>: V Samko; J Willcock, J Järvi, D Gregor, A Lumsdaine (February 26, 2006) Lambda expressions and closures for C++

</li>

<li id="cite_note-12"><a href="#cite_ref-12">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090831133626/http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/Blocks/Articles/00_Introduction.html">"Mac Dev Center: Blocks Programming Topics: Introduction"</a>. Archived from <a rel="nofollow" class="external text" href="https://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/Blocks/Articles/00_Introduction.html">the original</a> on 2009-08-31.</cite>

</li>

<li id="cite_note-13"><a href="#cite_ref-13">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://play.golang.org/p/lZHXrX-yR6">"2 examples in Go that you can have partial application"</a>.</cite>

</li>

<li id="cite_note-14"><a href="#cite_ref-14">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.rs/partial_application">"partial_application"</a>. Docs.rs. Retrieved 2020-11-03.</cite>

</li>

<li id="cite_note-15"><a href="#cite_ref-15">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://srfi.schemers.org/srfi-26/srfi-26.html">"SRFI 26: Notation for Specializing Parameters without Currying"</a>.</cite>

</li>

<li id="cite_note-16"><a href="#cite_ref-16">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://ejohn.org/blog/partial-functions-in-javascript/">"John Resig - Partial Application in JavaScript"</a>.</cite>

</li>

<li id="cite_note-17"><a href="#cite_ref-17">^</a> <cite id="CITEREFKatz2010" class="citation web cs1">Katz, Ian (July 23, 2010). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20181106235506/http://tinylittlelife.org/?p=249">"Lua Code for Curry (Currying Functions)"</a>. Archived from <a rel="nofollow" class="external text" href="http://tinylittlelife.org/?p=249">the original</a> on 2018-11-06.</cite>

</li>

<li id="cite_note-18"><a href="#cite_ref-18">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://perlgeek.de/blog-en/perl-5-to-6/28-currying.html">"Blog | Perlgeek.de :: Currying"</a>.</cite>

</li>

<li id="cite_note-19"><a href="#cite_ref-19">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://docs.python.org/whatsnew/2.5.html#pep-309-partial-function-application">"What's New in Python 2.5 — Python 3.10.0 documentation"</a>.</cite>

</li>

<li id="cite_note-20"><a href="#cite_ref-20">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.mathworks.co.uk/help/matlab/matlab_prog/anonymous-functions.html">"Anonymous Functions - MATLAB & Simulink - MathWorks United Kingdom"</a>.</cite>

</li>

<li id="cite_note-21"><a href="#cite_ref-21">^</a> <a rel="nofollow" class="external text" href="https://stackoverflow.com/q/9154271">Partial Function Evaluation in MATLAB</a>

</li>

<li id="cite_note-22"><a href="#cite_ref-22">^</a> <a rel="nofollow" class="external text" href="https://common-lisp.net/project/bknr/static/lmman/fd-clo.xml">Closures in ZetaLisp</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20120319071329/http://common-lisp.net/project/bknr/static/lmman/fd-clo.xml">Archived</a> 2012-03-19 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>

</li>

</ol></div>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

<ul><li>Leonidas Fegaras. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20110720102933/http://lambda.uta.edu/cse5317/l12.ppt">"Functional Languages and Higher-Order Functions"</a>. CSE5317/CSE4305: Design and Construction of Compilers. University of Texas at Arlington.</li></ul>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><a rel="nofollow" class="external text" href="http://rosettacode.org/wiki/First-class_functions">First-class functions</a> on <a href="Rosetta_Code" title="Rosetta Code">Rosetta Code</a>.</li>

<li><a rel="nofollow" class="external text" href="http://www.ibm.com/developerworks/linux/library/l-highfunc/index.html">Higher order functions</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20191112160401/http://www.ibm.com/developerworks/linux/library/l-highfunc/index.html">Archived</a> November 12, 2019, at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> at IBM developerWorks</li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Data_types177" style="padding:3px"><table class="nowraplinks hlist mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Data_types177" style="font-size:114%;margin:0 4em"><a href="Data_type" title="Data type">Data types</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Units_of_information" title="Units of information">Uninterpreted</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<li><a href="Ternary_numeral_system#Tryte" title="Ternary numeral system">Tryte</a></li>

<li><a href="Bit_array" title="Bit array">Bit array</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Numeric</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Arbitrary-precision_arithmetic" title="Arbitrary-precision arithmetic">Arbitrary-precision or bignum</a></li>

<li><a href="Complex_data_type" title="Complex data type">Complex</a></li>

<li><a href="Decimal_data_type" title="Decimal data type">Decimal</a></li>

<li><a href="Fixed-point_arithmetic" title="Fixed-point arithmetic">Fixed point</a></li>

<li><a href="Block_floating_point" title="Block floating point">Block floating point</a></li>

<li><a href="Floating-point_arithmetic" title="Floating-point arithmetic">Floating point</a>

<ul><li>Reduced precision

<ul><li><a href="Minifloat" title="Minifloat">Minifloat</a></li>

<li><a href="Half-precision_floating-point_format" title="Half-precision floating-point format">Half precision</a></li>

<li><a href="Bfloat16_floating-point_format" title="Bfloat16 floating-point format">bfloat16</a></li></ul></li>

<li><a href="Single-precision_floating-point_format" title="Single-precision floating-point format">Single precision</a></li>

<li><a href="Double-precision_floating-point_format" title="Double-precision floating-point format">Double precision</a></li>

<li><a href="Quadruple-precision_floating-point_format" title="Quadruple-precision floating-point format">Quadruple precision</a></li>

<li><a href="Octuple-precision_floating-point_format" title="Octuple-precision floating-point format">Octuple precision</a></li>

<li><a href="Extended_precision" title="Extended precision">Extended precision</a>

<ul><li><a href="Long_double" title="Long double">Long double</a></li></ul></li></ul></li>

<li><a href="Integer_(computer_science)" title="Integer (computer science)">Integer</a>

<ul><li><a href="Signedness" title="Signedness">signedness</a></li></ul></li>

<li><a href="Interval_arithmetic#Implementations" title="Interval arithmetic">Interval</a></li>

<li><a href="Rational_data_type" title="Rational data type">Rational</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Pointer_(computer_programming)" title="Pointer (computer programming)">Pointer</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Memory_address" title="Memory address">Address</a>

<ul><li><a href="Physical_address" title="Physical address">physical</a></li>

<li><a href="Virtual_address_space" title="Virtual address space">virtual</a></li></ul></li>

<li><a href="Reference_(computer_science)" title="Reference (computer science)">Reference</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Plain_text" title="Plain text">Text</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Character_(computing)" title="Character (computing)">Character</a></li>

<li><a href="String_(computer_science)" title="String (computer science)">String</a>

<ul><li><a href="Null-terminated_string" title="Null-terminated string">null-terminated</a></li></ul></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Composite_data_type" title="Composite data type">Composite</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Algebraic_data_type" title="Algebraic data type">Algebraic data type</a>

<ul><li><a href="Generalized_algebraic_data_type" title="Generalized algebraic data type">generalized</a></li></ul></li>

<li><a href="Array_(data_type)" title="Array (data type)">Array</a></li>

<li><a href="Associative_array" title="Associative array">Associative array</a></li>

<li><a href="Class_(computer_programming)" title="Class (computer programming)">Class</a></li>

<li><a href="Dependent_type" title="Dependent type">Dependent</a></li>

<li><a href="Intuitionistic_type_theory#Equality_type" title="Intuitionistic type theory">Equality</a></li>

<li><a href="Inductive_type" title="Inductive type">Inductive</a></li>

<li><a href="Intersection_type" title="Intersection type">Intersection</a></li>

<li><a href="Object_(computer_science)" title="Object (computer science)">Object</a>

<ul><li><a href="Metaobject" title="Metaobject">metaobject</a></li></ul></li>

<li><a href="Option_type" title="Option type">Option type</a></li>

<li><a href="Product_type" title="Product type">Product</a></li>

<li><a href="Record_(computer_science)" title="Record (computer science)">Record or Struct</a></li>

<li><a href="Refinement_type" title="Refinement type">Refinement</a></li>

<li><a href="Union_type" title="Union type">Union</a>

<ul><li><a href="Tagged_union" title="Tagged union">tagged</a></li></ul></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Other</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Boolean_data_type" title="Boolean data type">Boolean</a></li>

<li><a href="Bottom_type" title="Bottom type">Bottom type</a></li>

<li><a href="Container_(abstract_data_type)" title="Container (abstract data type)">Collection</a></li>

<li><a href="Enumerated_type" title="Enumerated type">Enumerated type</a></li>

<li><a href="Exception_handling" title="Exception handling">Exception</a></li>

<li><a href="Function_type" title="Function type">Function type</a></li>

<li><a href="Opaque_data_type" title="Opaque data type">Opaque data type</a></li>

<li><a href="Recursive_data_type" title="Recursive data type">Recursive data type</a></li>

<li><a href="Semaphore_(programming)" title="Semaphore (programming)">Semaphore</a></li>

<li><a href="Stream_(computing)" title="Stream (computing)">Stream</a></li>

<li><a href="Strongly_typed_identifier" title="Strongly typed identifier">Strongly typed identifier</a></li>

<li><a href="Type_class" title="Type class">Type class</a></li>

<li><a href="Empty_type" title="Empty type">Empty type</a></li>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Related topics</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Abstract_data_type" title="Abstract data type">Abstract data type</a></li>

<li><a href="Boxing_(computer_programming)" title="Boxing (computer programming)">Boxing</a></li>

<li><a href="Data_structure" title="Data structure">Data structure</a></li>

<li><a href="Generic_programming" title="Generic programming">Generic</a></li>

<ul><li><a href="Metaclass" title="Metaclass">metaclass</a></li></ul></li>

<li><a href="Parametric_polymorphism" title="Parametric polymorphism">Parametric polymorphism</a></li>

<li><a href="Primitive_data_type" title="Primitive data type">Primitive data type</a></li>

<li><a href="Interface_(object-oriented_programming)" title="Interface (object-oriented programming)">Interface</a></li>

<li><a href="Subtyping" title="Subtyping">Subtyping</a></li>

<li><a href="Type_constructor" title="Type constructor">Type constructor</a></li>

<li><a href="Type_conversion" title="Type conversion">Type conversion</a></li>

<li><a href="Type_system" title="Type system">Type system</a></li>

<li><a href="Type_theory" title="Type theory">Type theory</a></li>

<li><a href="Variable_(computer_science)" title="Variable (computer science)">Variable</a></li></ul>

</div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-06-30" href="https://en.wikipedia.org/wiki/?title=First-class_function&oldid=1298118440">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>